#pragma once

#include <signal.h>
#include <functional>
#include <string>
#include "Log.hpp"
#include "Socket.hpp"

using func_t = std::function<std::string(std::string&)>;

class TcpServer {
public:
    TcpServer(uint16_t port, func_t callback) 
        :port_(port), callback_(callback) {}
    
    bool InitServer() {
        listensockfd_.Socket();
        listensockfd_.Bind(port_);
        listensockfd_.Listen();
        lg(Info, "Init server done.");
        return true;
    }

    void Start() {
        // 忽略SIGCHLD信号，避免子进程退出时产生僵尸进程
        // 当子进程结束时，内核会自动回收资源，父进程不需要调用wait()
        signal(SIGCHLD, SIG_IGN);
        while (true) {
            // 接收新的客户端连接
            std::string clientip;
            uint16_t clientport;
            int sockfd = listensockfd_.Accepet(&clientip, &clientport);
            if (sockfd < 0) continue; // 如果接受连接失败，继续等待下一个连接
            lg(Info, "Accepet a new link, sockfd:%d, clientip:%s, clinetport:%d", sockfd, clientip.c_str(), clientport);
            //提供服务(多进程版)
            if (fork() == 0) { // 子进程代码区域
                listensockfd_.Close();// 关闭监听套接字，子进程不需要监听新的连接
                std::string inbuff_stream;// 存储从客户端读取的数据流
                //数据计算
                while (true) {
                    char buffer[128];
                    ssize_t n  = read(sockfd, buffer, sizeof(buffer));
                    if (n > 0) {
                        buffer[n] = 0;
                        inbuff_stream += buffer;
                        lg(Debug, "debug: %s", inbuff_stream.c_str());//回显读到的信息
                         
                        while (true) { // 循环处理数据流中的完整报文
                            std::string info = callback_(inbuff_stream);// callback_函数会从inbuffer_stream中提取并处理完整报文
                            if (info.empty()) break;
                            //inbuff_stream有多个请求
                            lg(Debug, "debug, response:\n%s", info.c_str());
                            // lg(Debug, "%s", inbuff_stream.c_str());
                            write(sockfd, info.c_str(), info.size());   
                        }

                        // //inbuff_stream只有一个请求
                        // std::string info = callback_(inbuff_stream);
                        // if (info.empty()) continue;
                        // write(sockfd, info.c_str(), info.size());
                    }
                    else if (n == 0) break;// 客户端关闭连接，读取返回0
                    else break;// 读取发生错误，跳出循环
                }
                exit(0);// 子进程处理完客户端请求后退出
            }
            // 父进程代码区域
            close(sockfd);// 关闭已复制的客户端套接字，父进程不需要与客户端通信
        }
    }
    
    ~TcpServer() {}
private:
    uint16_t port_;
    Sock listensockfd_;
    func_t callback_;
};

